// NetDriver.cpp
void UNetDriver::RegisterTickEvents(class UWorld* InWorld)
{
  if (InWorld)
  {
    TickDispatchDelegateHandle = InWorld->OnTickDispatch().AddUObject(this, &UNetDriver::InternalTickDispatch);
    PostTickDispatchDelegateHandle  = InWorld->OnPostTickDispatch().AddUObject(this, &UNetDriver::PostTickDispatch);
    TickFlushDelegateHandle = InWorld->OnTickFlush().AddUObject(this, &UNetDriver::InternalTickFlush);
    PostTickFlushDelegateHandle = InWorld->OnPostTickFlush().AddUObject(this, &UNetDriver::PostTickFlush);
  }
}

// NetDriver.cpp/UNetDriver::TickDispatch
void UNetDriver::TickDispatch( float DeltaTime )
{
  SendCycles=0;
  // Manage realtime values
  {
    const double CurrentRealtime = FPlatformTime::Seconds();
    LastTickDispatchRealtime = CurrentRealtime;
    // Check to see if too much time is passing between ticks
    // Setting this to somewhat large value for now, but small enough to catch blocking calls that are causing timeouts
    constexpr float TickLogThreshold = 5.0f;
    const float DeltaRealtime = CurrentRealtime - LastTickDispatchRealtime;
    bDidHitchLastFrame = (DeltaTime > TickLogThreshold || DeltaRealtime > TickLogThreshold);
    if (bDidHitchLastFrame)
    {
      UE_LOG( LogNet, Log, TEXT( "UNetDriver::TickDispatch: Very long time between ticks. DeltaTime: %2.2f, Realtime: %2.2f. %s" ), DeltaTime, DeltaRealtime, *GetName() );
    }
  }
  // Get new time.
  ElapsedTime += DeltaTime;
  IncomingBunchProcessingElapsedFrameTimeMS = 0.0f;

  // Checks for standby cheats if enabled
  UpdateStandbyCheatStatus();
  ResetNetworkMetrics();

  if (ServerConnection == nullptr)
  {
    // Delete any straggler connections
    {
      QUICK_SCOPE_CYCLE_COUNTER(UNetDriver_TickDispatch_CheckClientConnectionCleanup)
      for (int32 ConnIdx=ClientConnections.Num()-1; ConnIdx>=0; ConnIdx--)
      {
        UNetConnection* CurConn = ClientConnections[ConnIdx];
        if (IsValid(CurConn))
        {
          if (CurConn->GetConnectionState() == USOCK_Closed)
          {
            CurConn->CleanUp();
          }
          else
          {
            CurConn->PreTickDispatch();
          }
        }
      }
    }

    // Clean up recently disconnected client tracking
    if (RecentlyDisconnectedClients.Num() > 0)
    {
      int32 NumToRemove = 0;
      for (const FDisconnectedClient& CurElement : RecentlyDisconnectedClients)
      {
        if ((LastTickDispatchRealtime - CurElement.DisconnectTime) >= RecentlyDisconnectedTrackingTime)
        {
          verify(MappedClientConnections.Remove(CurElement.Address) == 1);
          NumToRemove++;
        }
        else
        {
          break;
        }
      }
      if (NumToRemove > 0)
      {
        RecentlyDisconnectedClients.RemoveAt(0, NumToRemove);
      }
    }
  }

  else if (IsValid(ServerConnection))
  {
    ServerConnection->PreTickDispatch();
  }
#if RPC_CSV_TRACKER
  GReceiveRPCTimingEnabled = (NetDriverName == NAME_GameNetDriver && ShouldEnableScopeSecondsTimers()) && (ServerConnection==nullptr);
#endif
}

void UIpNetDriver::TickDispatch(float DeltaTime)
{
  LLM_SCOPE_BYTAG(NetDriver);
  Super::TickDispatch( DeltaTime );
  const bool bUsingReceiveThread = SocketReceiveThreadRunnable.IsValid();
  if (bUsingReceiveThread)
  {
    SocketReceiveThreadRunnable->PumpOwnerEventQueue();
  }

#if !UE_BUILD_SHIPPING
  ...
#endif
  ...
  // Process all incoming packets
  for (FPacketIterator It(this); It; ++It)
  {

    FReceivedPacketView ReceivedPacket;
    FInPacketTraits& ReceivedTraits = ReceivedPacket.Traits;
    bool bOk = It.GetCurrentPacket(ReceivedPacket);
    const TSharedRef<const FInternetAddr> FromAddr = ReceivedPacket.Address.ToSharedRef();
    UNetConnection* Connection = nullptr;
    UIpConnection* const MyServerConnection = GetServerConnection();
    if (bOk)
    {
      // Immediately stop processing (continuing to next receive), for empty packets (usually a DDoS)
      if (ReceivedPacket.DataView.NumBits() == 0)
      {
        DDoS.IncBadPacketCounter();
        continue;
      }
      FPacketAudit::NotifyLowLevelReceive((uint8*)ReceivedPacket.DataView.GetData(), ReceivedPacket.DataView.NumBytes());
    }

    else
    {
      if (IsRecvFailBlocking(ReceivedPacket.Error))
      {
        break;
      }
      else if (ReceivedPacket.Error != SE_ECONNRESET && ReceivedPacket.Error != SE_UDP_ERR_PORT_UNREACH)
      {
        //...log
        continue;
      }
    }

    if (MyServerConnection)
    {
      if (MyServerConnection->RemoteAddr->CompareEndpoints(*FromAddr))
      {
        Connection = MyServerConnection;
      }
      else //...log
    }
    if (Connection == nullptr) { ... }
    if( bOk == false ) { if( Connection ) { ... } }
    else {
      bool bIgnorePacket = false;
      // If we didn't find a client connection, maybe create a new one.
      if (Connection == nullptr) { ... }
    }
  }
  if (NewIPHashes.Num() > 0) TickNewIPTracking(DeltaTime);
  DDoS.PostFrameReceive();
}

void UNetDriver::PostTickDispatch()
{
  // Flush out of order packet caches for connections that did not receive the missing packets during TickDispatch
  if (ServerConnection != nullptr)
  {
    if (IsValid(ServerConnection))
    {
      ServerConnection->PostTickDispatch();
    }
  }
  TArray<UNetConnection*> ClientConnCopy = ClientConnections;
  for (UNetConnection* CurConn : ClientConnCopy)
  {
    if (IsValid(CurConn))
    {
      CurConn->PostTickDispatch();
    }
  }

#if UE_WITH_IRIS
  PostDispatchSendUpdate();
#endif
  if (ReplicationDriver)
  {
    ReplicationDriver->PostTickDispatch();
  }

  if (GReceiveRPCTimingEnabled)
  {
    GRPCCSVTracker.EndTickDispatch();
    GReceiveRPCTimingEnabled = false;
  }
  if (bPendingDestruction)
  {
    if (World)
    {
      GEngine->DestroyNamedNetDriver(World, NetDriverName);
    }
    else
    {
      UE_LOG(LogNet, Error, TEXT("NetDriver %s pending destruction without valid world."), *NetDriverName.ToString());
    }
    bPendingDestruction = false;
  }
}

void UNetDriver::TickFlush(float DeltaSeconds)
{
  // ...trace
  bool bEnableTimer = (NetDriverName == NAME_GameNetDriver) && ShouldEnableScopeSecondsTimers();
  if (bEnableTimer)
  {
    GTickFlushGameDriverTimeSeconds = 0.0;
  }
  FSimpleScopeSecondsCounter ScopedTimer(GTickFlushGameDriverTimeSeconds, bEnableTimer);

  if (IsServer() && ClientConnections.Num() > 0 && !bSkipServerReplicateActors)
  {
    // Update all clients.
#if WITH_SERVER_CODE
    CSV_SCOPED_TIMING_STAT_EXCLUSIVE(ServerReplicateActors);
#if UE_WITH_IRIS
    ...
#endif // UE_WITH_IRIS
    {
      ServerReplicateActors(DeltaSeconds);
    }
#endif // WITH_SERVER_CODE
  }
#if UE_WITH_IRIS
  ...
#endif // UE_WITH_IRIS

int32 UNetDriver::ServerReplicateActors(float DeltaSeconds)
{
  SCOPE_CYCLE_COUNTER(STAT_NetServerRepActorsTime);
#if WITH_SERVER_CODE
  if ( ClientConnections.Num() == 0 ) { return 0; }

  GetMetrics()->SetInt(UE::Net::Metric::NumReplicatedActors,0 );
  GetMetrics()->SetInt(UE::Net::Metric::NumReplicatedActorBytes, 0);

#if CSV_PROFILER_STATS
  FScopedNetDriverStats NetDriverStats(this);
  GNumClientConnections = ClientConnections.Num();
#endif
  if (ReplicationDriver)
  {
    return ReplicationDriver->ServerReplicateActors(DeltaSeconds);
  }

  check( World );
  // Bump the ReplicationFrame value to invalidate any properties marked as "unchanged" for this frame.
  ReplicationFrame++;
  int32 Updated = 0;
  const int32 NumClientsToTick = ServerReplicateActors_PrepConnections( DeltaSeconds );
  if ( NumClientsToTick == 0 ) { return 0; } // No connections are ready this frame

  AWorldSettings* WorldSettings = World->GetWorldSettings();
  bool bCPUSaturated    = false;
  float ServerTickTime  = GEngine->GetMaxTickRate( DeltaSeconds );
  if ( ServerTickTime == 0.f )
  {
    ServerTickTime = DeltaSeconds;
  }
  else
  {
    ServerTickTime  = 1.f/ServerTickTime;
    bCPUSaturated  = DeltaSeconds > 1.2f * ServerTickTime;
  }
  TArray<FNetworkObjectInfo*> ConsiderList;
  ConsiderList.Reserve( GetNetworkObjectList().GetActiveObjects().Num() );
  // Build the consider list (actors that are ready to replicate)
  ServerReplicateActors_BuildConsiderList( ConsiderList, ServerTickTime );
  TSet<UNetConnection*> ConnectionsToClose;
  FMemMark Mark( FMemStack::Get() );
  if (OnPreConsiderListUpdateOverride.IsBound())
  {
    OnPreConsiderListUpdateOverride.Execute({ DeltaSeconds, nullptr, bCPUSaturated }, Updated, ConsiderList);
  }

  for ( int32 i=0; i < ClientConnections.Num(); i++ )
  {
    UNetConnection* Connection = ClientConnections[i];
    check(Connection);
    // net.DormancyValidate can be set to 2 to validate all dormant actors against last known state before going dormant
    if ( GNetDormancyValidate == 2 )
    {
      ...
    }

    // if this client shouldn't be ticked this frame
    if (i >= NumClientsToTick)
    {
// UE_LOG(LogNet, Log, TEXT("skipping update to %s"),*Connection->GetName());
// then mark each considered actor as bPendingNetUpdate so that they will be considered again the next frame when the connection is actually ticked
      for (int32 ConsiderIdx = 0; ConsiderIdx < ConsiderList.Num(); ConsiderIdx++)
      {
        AActor *Actor = ConsiderList[ConsiderIdx]->Actor;
// if the actor hasn't already been flagged by another connection,
        if (Actor != NULL && !ConsiderList[ConsiderIdx]->bPendingNetUpdate)
        {
// find the channel
          UActorChannel *Channel = Connection->FindActorChannelRef(ConsiderList[ConsiderIdx]->WeakActor);
// and if the channel last update time doesn't match the last net update time for the actor
          if (Channel != NULL && Channel->LastUpdateTime < ConsiderList[ConsiderIdx]->LastNetUpdateTimestamp)
          {
//UE_LOG(LogNet, Log, TEXT("flagging %s for a future update"),*Actor->GetName());
// flag it for a pending update
            ConsiderList[ConsiderIdx]->bPendingNetUpdate = true;
          }
        }
      }
// clear the time sensitive flag to avoid sending an extra packet to this connection
      Connection->TimeSensitive = false;
    }

    else if (Connection->ViewTarget)
    {
      const int32 LocalNumSaturated = GNumSaturatedConnections;
// Make a list of viewers this connection should consider (this connection and children of this connection)
      TArray<FNetViewer>& ConnectionViewers = WorldSettings->ReplicationViewers;
      ConnectionViewers.Reset();
      new( ConnectionViewers )FNetViewer( Connection, DeltaSeconds );
      for ( int32 ViewerIndex = 0; ViewerIndex < Connection->Children.Num(); ViewerIndex++ )
      {
        if ( Connection->Children[ViewerIndex]->ViewTarget != NULL )
        {
          new( ConnectionViewers )FNetViewer( Connection->Children[ViewerIndex], DeltaSeconds );
        }
      }

      // send ClientAdjustment if necessary
      // we do this here so that we send a maximum of one per packet to that client; there is no value in stacking additional corrections
      if ( Connection->PlayerController )
      {
        Connection->PlayerController->SendClientAdjustment();
      }
      for ( int32 ChildIdx = 0; ChildIdx < Connection->Children.Num(); ChildIdx++ )
      {
        if ( Connection->Children[ChildIdx]->PlayerController != NULL )
        {
          Connection->Children[ChildIdx]->PlayerController->SendClientAdjustment();
        }
      }

      FMemMark RelevantActorMark(FMemStack::Get());
      const bool bProcessConsiderListIsBound = OnProcessConsiderListOverride.IsBound();
      if (bProcessConsiderListIsBound)
      {
        OnProcessConsiderListOverride.Execute( { DeltaSeconds, Connection, bCPUSaturated }, Updated, ConsiderList );
      }

      if (!bProcessConsiderListIsBound)
      {
        FActorPriority* PriorityList = NULL;
        FActorPriority** PriorityActors = NULL;
        // Get a sorted list of actors for this connection
        const int32 FinalSortedCount = ServerReplicateActors_PrioritizeActors(Connection, ConnectionViewers, ConsiderList, bCPUSaturated, PriorityList, PriorityActors);

        // Process the sorted list of actors for this connection
        TInterval<int32> ActorsIndexRange(0, FinalSortedCount);
        const int32 LastProcessedActor = ServerReplicateActors_ProcessPrioritizedActorsRange(Connection, ConnectionViewers, PriorityActors, ActorsIndexRange, Updated);
        ServerReplicateActors_MarkRelevantActors(Connection, ConnectionViewers, LastProcessedActor, FinalSortedCount, PriorityActors);
      }

      RelevantActorMark.Pop();
      ConnectionViewers.Reset();
      Connection->LastProcessedFrame = ReplicationFrame;
      const bool bWasSaturated = GNumSaturatedConnections > LocalNumSaturated;
      Connection->TrackReplicationForAnalytics(bWasSaturated);
    }

    if (Connection->GetPendingCloseDueToReplicationFailure())
    {
      ConnectionsToClose.Add(Connection);
    }
  }

  if (OnPostConsiderListUpdateOverride.IsBound())
  {
    OnPostConsiderListUpdateOverride.ExecuteIfBound( { DeltaSeconds, nullptr, bCPUSaturated }, Updated, ConsiderList );
  }

  // shuffle the list of connections if not all connections were ticked
  if (NumClientsToTick < ClientConnections.Num())
  {
    int32 NumConnectionsToMove = NumClientsToTick;
    while (NumConnectionsToMove > 0)
    {
      // move all the ticked connections to the end of the list so that the other connections are considered first for the next frame
      UNetConnection *Connection = ClientConnections[0];
      ClientConnections.RemoveAt(0,1);
      ClientConnections.Add(Connection);
      NumConnectionsToMove--;
    }
  }
  Mark.Pop();

#if NET_DEBUG_RELEVANT_ACTORS
  //...debug
#endif // NET_DEBUG_RELEVANT_ACTORS
  for (UNetConnection* ConnectionToClose : ConnectionsToClose)
  {
    ConnectionToClose->Close();
  }
  return Updated;
#else
  return 0;
#endif // WITH_SERVER_CODE
}

  // Reset queued bunch amortization timer
  ProcessQueuedBunchesCurrentFrameMilliseconds = 0.0f;
  // Poll all sockets.
  if( ServerConnection )
  {
    // Queue client voice packets in the server's voice channel
    ProcessLocalClientPackets();
    ServerConnection->Tick(DeltaSeconds);
  }
  else
  {
    // Queue up any voice packets the server has locally
    ProcessLocalServerPackets();
  }
  {
    QUICK_SCOPE_CYCLE_COUNTER(STAT_NetDriver_TickClientConnections)
    for (UNetConnection* Connection : ClientConnections)
    {
      Connection->Tick(DeltaSeconds);
    }
  }

  if (ConnectionlessHandler.IsValid())
  {
    ConnectionlessHandler->Tick(DeltaSeconds);
    FlushHandler();
  }

  //... debug
  //... Iris
  UpdateNetworkStats();
  // Send the current values of metrics to all of the metrics listeners.
  GetMetrics()->ProcessListeners();

  // Update the lag state
  UpdateNetworkLagState();
}

if (!IsInternalAck() && MaxNetTickRateFloat < EngineTickRate && DesiredTickRate > 0.0f)
{
    const float MinNetFrameTime = 1.0f/DesiredTickRate;
    if (FrameTime < MinNetFrameTime)
    {
      return;
    }
}

if (IsInternalAck())
{
  ...
}

if ( CurrentRealtimeSeconds - StatUpdateTime > StatPeriod )
{
  ...
  // Add TotalPacketsLost to total since InTotalPackets only counts ACK packets
  InPacketsLossPercentage.UpdateLoss(InPacketsLost, InTotalPackets + InTotalPacketsLost, StatPeriodCount);
  // Using OutTotalNotifiedPackets so we do not count packets that are still in transit.
  OutPacketsLossPercentage.UpdateLoss(OutPacketsLost, OutTotalNotifiedPackets, StatPeriodCount);
  ...
}

if (bConnectionPendingCloseDueToSocketSendFailure)
{
    Close(ENetCloseResult::SocketSendFailure);
    bConnectionPendingCloseDueToSocketSendFailure = false;
    // early out
    return;
}

const float Timeout = GetTimeoutValue();
const bool bReceiveTimedOut = (CurrentRealtimeSeconds - LastReceiveRealtime) > Timeout;
const bool bGracefulCloseTimedOut = (GetConnectionState() == USOCK_Closing) && (DriverElapsedTime > bGracefulCloseTimedOut);
if (bReceiveTimedOut || bGracefulCloseTimedOut)
{
  ...
}

if (CVarTickAllOpenChannels.GetValueOnAnyThread() == 0) {
  for( int32 i=ChannelsToTick.Num()-1; i>=0; i-- ) {
    ChannelsToTick[i]->Tick();
    if (ChannelsToTick[i]->CanStopTicking())
      ChannelsToTick.RemoveAt(i);
  }
}
else {
  for (int32 i = OpenChannels.Num() - 1; i >= 0; i--) {
    if (OpenChannels[i]) OpenChannels[i]->Tick();
    else UE_LOG(LogNet, Warning, TEXT("UNetConnection::Tick: null channel in OpenChannels array. %s"), *Describe());
  }
}

for ( auto ProcessingActorMapIter = KeepProcessingActorChannelBunchesMap.CreateIterator(); ProcessingActorMapIter; ++ProcessingActorMapIter ) {
  ...
}

  if ( TimeSensitive || (Driver->GetElapsedTime() - LastSendTime) > Driver->KeepAliveTime)
  {
    bool bHandlerHandshakeComplete = !Handler.IsValid() || Handler->IsFullyInitialized();
    // Delay any packet sends on the server, until we've verified that a packet has been received from the client.
    if (bHandlerHandshakeComplete && HasReceivedClientPacket())
    {
      FlushNet();
    }
  }

// Resend any queued up raw packets (these come from the reliability handler)
BufferedPacket* ResendPacket = Handler->GetQueuedRawPacket();
if (ResendPacket && Driver->IsNetResourceValid())
{
  Handler->SetRawSend(true);
  while (ResendPacket != nullptr)
  {
    LowLevelSend(ResendPacket->Data, ResendPacket->CountBits, ResendPacket->Traits);
    ResendPacket = Handler->GetQueuedRawPacket();
  }
  Handler->SetRawSend(false);
}
...

void UNetDriver::PostTickFlush()
{
#if UE_WITH_IRIS
  ...
#endif // UE_WITH_IRIS
  if (World && !bSkipClearVoicePackets)
  {
    UOnlineEngineInterface::Get()->ClearVoicePackets(World);
  }

  if (bPendingDestruction)
  {
    if (World)
    {
      GEngine->DestroyNamedNetDriver(World, NetDriverName);
    }
    else
    {
      UE_LOG(LogNet, Error, TEXT("NetDriver %s pending destruction without valid world."), *NetDriverName.ToString());
    }
    bPendingDestruction = false;
  }
}

void UEngine::SetClientTravel( UWorld *InWorld, const TCHAR* NextURL, ETravelType InTravelType )
{
    FWorldContext &Context = GetWorldContextFromWorldChecked(InWorld);
    Context.TravelURL    = NextURL;
    Context.TravelType   = InTravelType;
    ...
}

WorldContext.PendingNetGame = NewObject<UPendingNetGame>();
WorldContext.PendingNetGame->Initialize(URL); //-V595
WorldContext.PendingNetGame->InitNetDriver(); //-V595

// PendingNetGame.cpp
if( NetDriver->InitConnect( this, URL, ConnectionError ) )
{
  FNetDelegates::OnPendingNetGameConnectionCreated.Broadcast(this);
  ULocalPlayer* LocalPlayer = GEngine->GetFirstGamePlayer(this);
  if (LocalPlayer)
  {
    LocalPlayer->PreBeginHandshake(ULocalPlayer::FOnPreBeginHandshakeCompleteDelegate::CreateWeakLambda(this,
      [this]()
      {
        BeginHandshake();
      }));
  }
  else
  {
    BeginHandshake();
  }
}
...

void UPendingNetGame::BeginHandshake()
{
  // Kick off the connection handshake
  UNetConnection* ServerConn = NetDriver->ServerConnection;
  if (ServerConn->Handler.IsValid()) { ... }
  else
  {
    SendInitialJoin();
  }
}